जावास्क्रिप्ट प्रायव्हेट मेथड डेकोरेटर्स: क्लास सुधारणा आणि व्हॅलिडेशनचा सखोल अभ्यास

आधुनिक जावास्क्रिप्ट सतत विकसित होत आहे, ज्यामुळे डेव्हलपर्सना अधिक अर्थपूर्ण, सुव्यवस्थित आणि मजबूत कोड लिहिण्यास सक्षम करणारी नवीन शक्तिशाली वैशिष्ट्ये मिळत आहेत. या वैशिष्ट्यांपैकी सर्वात अपेक्षित वैशिष्ट्ये म्हणजे डेकोरेटर्स. TC39 प्रक्रियेत स्टेज 3 वर पोहोचल्यानंतर, डेकोरेटर्स भाषेचा एक मानक भाग बनण्याच्या उंबरठ्यावर आहेत आणि ते मेटाप्रोग्रामिंग आणि क्लास-आधारित आर्किटेक्चरकडे पाहण्याचा आपला दृष्टिकोन बदलण्याचे वचन देतात.

डेकोरेटर्स विविध क्लास घटकांवर लागू केले जाऊ शकतात, तरीही हा लेख एका विशेष शक्तिशाली अनुप्रयोगावर लक्ष केंद्रित करतो: प्रायव्हेट मेथड डेकोरेटर्स. आम्ही हे शोधू की हे विशेष डेकोरेटर्स आपल्याला आपल्या क्लासेसच्या अंतर्गत कार्यप्रणालीमध्ये सुधारणा आणि व्हॅलिडेशन करण्याची कशी परवानगी देतात, ज्यामुळे खऱ्या अर्थाने एन्कॅप्सुलेशनला प्रोत्साहन मिळते आणि त्याच वेळी शक्तिशाली, पुन्हा वापरता येण्याजोगे वर्तन जोडले जाते. जागतिक स्तरावर जटिल ॲप्लिकेशन्स, लायब्ररी आणि फ्रेमवर्क तयार करण्यासाठी हा एक गेम-चेंजर आहे.

पायाभूत माहिती: डेकोरेटर्स म्हणजे नक्की काय?

मूलतः, डेकोरेटर्स हे मेटाप्रोग्रामिंगचे एक स्वरूप आहेत. सोप्या भाषेत सांगायचे तर, ते विशेष प्रकारचे फंक्शन्स आहेत जे इतर फंक्शन्स, क्लासेस किंवा प्रॉपर्टीजमध्ये बदल करतात. ते @expression फॉरमॅटचा वापर करून, कोड घटकांमध्ये त्यांच्या मूळ अंमलबजावणीत बदल न करता वर्तन जोडण्यासाठी एक घोषणात्मक सिंटॅक्स प्रदान करतात.

याचा विचार कार्यक्षमतेचे थर जोडण्यासारखा करा. लॉगिंग, टायमिंग किंवा व्हॅलिडेशन यासारख्या गोष्टींनी तुमच्या मुख्य बिझनेस लॉजिकला गोंधळात टाकण्याऐवजी, तुम्ही या क्षमतांसह एखादी मेथड 'डेकोरेट' करू शकता. हे एस्पेक्ट-ओरिएंटेड प्रोग्रामिंग (AOP) आणि सिंगल रिस्पॉन्सिबिलिटी प्रिन्सिपल यासारख्या शक्तिशाली सॉफ्टवेअर इंजिनिअरिंग तत्त्वांशी सुसंगत आहे, जिथे फंक्शन किंवा क्लासमध्ये बदल करण्याचे फक्त एकच कारण असावे.

डेकोरेटर्स येथे लागू केले जाऊ शकतात:

• क्लासेस
• मेथड्स (पब्लिक आणि प्रायव्हेट दोन्ही)
• फील्ड्स (पब्लिक आणि प्रायव्हेट दोन्ही)
• ॲक्सेसर्स (गेटर्स/सेटर्स)

आज आमचे लक्ष डेकोरेटर्स आणि जावास्क्रिप्टच्या आणखी एका आधुनिक वैशिष्ट्याच्या शक्तिशाली संयोगावर आहे: प्रायव्हेट क्लास सदस्य.

एक पूर्वअट: प्रायव्हेट क्लास वैशिष्ट्ये समजून घेणे

आपण प्रायव्हेट मेथडला प्रभावीपणे डेकोरेट करण्यापूर्वी, ती प्रायव्हेट कशामुळे बनते हे समजून घेणे आवश्यक आहे. अनेक वर्षे, जावास्क्रिप्ट डेव्हलपर्स अंडरस्कोर प्रीफिक्स (उदा., `_myPrivateMethod`) सारख्या संकेतांचा वापर करून प्रायव्हसीचे अनुकरण करत होते. तथापि, हा केवळ एक संकेत होता; मेथड तरीही सार्वजनिकरित्या ॲक्सेस करण्यायोग्य होती.

आधुनिक जावास्क्रिप्टने हॅश प्रीफिक्स (`#`) वापरून खऱ्या अर्थाने प्रायव्हेट क्लास सदस्य सादर केले.

या क्लासचा विचार करा:

            
class PaymentGateway {
  #apiKey;

  constructor(apiKey) {
    this.#apiKey = apiKey;
  }

  #createAuthHeader() {
    // Internal logic to create a secure header
    // This should never be called from outside the class
    const timestamp = Date.now();
    return `API-Key ${this.#apiKey}:${timestamp}`;
  }

  submitPayment(data) {
    const headers = this.#createAuthHeader();
    console.log('Submitting payment with header:', headers);
    // ... fetch call to the payment API
  }
}

const gateway = new PaymentGateway('my-secret-key');

// This works as intended
gateway.submitPayment({ amount: 100 });

// This will throw a SyntaxError or TypeError
// gateway.#createAuthHeader(); // Error: Private field '#createAuthHeader' must be declared in an enclosing class

            

              
                Copy
              
            
          

`#createAuthHeader` मेथड खऱ्या अर्थाने प्रायव्हेट आहे. ती फक्त `PaymentGateway` क्लासच्या आतूनच ॲक्सेस केली जाऊ शकते, ज्यामुळे मजबूत एन्कॅप्सुलेशन लागू होते. प्रायव्हेट मेथड डेकोरेटर्स याच पायावर तयार होतात.

प्रायव्हेट मेथड डेकोरेटरची रचना

प्रायव्हेट मेथडला डेकोरेट करणे हे पब्लिक मेथडला डेकोरेट करण्यापेक्षा थोडे वेगळे आहे, कारण त्याच्या प्रायव्हसीच्या स्वरूपामुळे. डेकोरेटरला थेट मेथड फंक्शन मिळत नाही. त्याऐवजी, त्याला टार्गेट व्हॅल्यू आणि एक `context` ऑब्जेक्ट मिळतो जो प्रायव्हेट सदस्याशी सुरक्षितपणे संवाद साधण्याचा मार्ग प्रदान करतो.

मेथड डेकोरेटर फंक्शनची सिग्नेचर अशी आहे: function(target, context)

• `target`: मेथड फंक्शन स्वतः (पब्लिक मेथड्ससाठी) किंवा प्रायव्हेट मेथड्ससाठी `undefined`. प्रायव्हेट मेथड्ससाठी, आपल्याला मेथड ॲक्सेस करण्यासाठी `context` ऑब्जेक्ट वापरावा लागेल.
• `context`: डेकोरेट केलेल्या घटकाबद्दल मेटाडेटा असलेला एक ऑब्जेक्ट. प्रायव्हेट मेथडसाठी, तो असा दिसतो:
• kind: एक स्ट्रिंग, 'method'.
• name: मेथडचे नाव स्ट्रिंगच्या स्वरूपात, उदा., '#myMethod'.
• access: प्रायव्हेट सदस्याचे मूल्य वाचण्यासाठी किंवा लिहिण्यासाठी get() आणि set() फंक्शन्स असलेला एक ऑब्जेक्ट. प्रायव्हेट डेकोरेटर्ससोबत काम करण्याची ही गुरुकिल्ली आहे.
• private: एक बुलियन, `true`.
• static: मेथड स्टॅटिक आहे की नाही हे दर्शवणारा एक बुलियन.
• addInitializer: क्लास डिफाइन झाल्यावर एकदा चालणारे लॉजिक नोंदवण्यासाठी एक फंक्शन.

एक साधा लॉगिंग डेकोरेटर

चला एक मूलभूत डेकोरेटर तयार करूया जो प्रायव्हेट मेथड कॉल केल्यावर फक्त लॉग करतो. हे उदाहरण स्पष्टपणे दर्शवते की मूळ मेथड मिळवण्यासाठी `context.access.get()` कसे वापरावे.

            
function logCall(target, context) {
  const methodName = context.name;

  // This decorator returns a new function that replaces the original method
  return function (...args) {
    console.log(`Calling private method: ${methodName}`);

    // Get the original method using the access object
    const originalMethod = context.access.get(this);

    // Call the original method with the correct 'this' context and arguments
    return originalMethod.apply(this, args);
  };
}

class DataService {
  @logCall
  #fetchData(url) {
    console.log(`   -> Fetching from ${url}...`);
    return { data: 'Sample Data' };
  }

  getUser() {
    return this.#fetchData('/api/user/1');
  }
}

const service = new DataService();
service.getUser();

// Console Output:
// Calling private method: #fetchData
//    -> Fetching from /api/user/1...

            

              
                Copy
              
            
          

या उदाहरणात, `@logCall` डेकोरेटर `#fetchData` ला एका नवीन फंक्शनने बदलतो. हे नवीन फंक्शन प्रथम एक मेसेज लॉग करते, नंतर मूळ `#fetchData` फंक्शनचा संदर्भ मिळवण्यासाठी `context.access.get(this)` वापरते, आणि शेवटी ते `.apply()` वापरून कॉल करते. मूळ फंक्शनला रॅप करण्याचा हा पॅटर्न बहुतेक डेकोरेटर वापराच्या प्रकरणांमध्ये केंद्रस्थानी असतो.

व्यावहारिक उपयोग १: मेथड सुधारणा आणि एओपी

डेकोरेटर्सचा एक प्राथमिक उपयोग म्हणजे क्रॉस-कटिंग कन्सर्न्स जोडणे—म्हणजे असे वर्तन जे ॲप्लिकेशनच्या अनेक भागांवर परिणाम करतात—मूळ लॉजिकमध्ये कोणताही बदल न करता. हे एस्पेक्ट-ओरिएंटेड प्रोग्रामिंग (AOP) चे सार आहे.

उदाहरण: @logExecutionTime सह परफॉर्मन्स टायमिंग

मोठ्या प्रमाणातील ॲप्लिकेशन्समध्ये, परफॉर्मन्स बॉटलनेक्स ओळखणे महत्त्वाचे असते. प्रत्येक मेथडमध्ये मॅन्युअली टायमिंग लॉजिक (`console.time`, `console.timeEnd`) जोडणे कंटाळवाणे आणि त्रुटी-प्रवण असते. एक डेकोरेटर हे काम सोपे करतो.

            
function logExecutionTime(target, context) {
  const methodName = context.name;

  return function (...args) {
    console.log(`Executing ${methodName}...`);
    const start = performance.now();

    const originalMethod = context.access.get(this);
    const result = originalMethod.apply(this, args);
    
    const end = performance.now();
    console.log(`Execution of ${methodName} finished in ${(end - start).toFixed(2)}ms.`);
    
    return result;
  };
}

class ReportGenerator {
  @logExecutionTime
  #processLargeDataset() {
    // Simulate a time-consuming operation
    let sum = 0;
    for (let i = 0; i < 100000000; i++) {
      sum += Math.sqrt(i);
    }
    return sum;
  }

  generate() {
    console.log('Starting report generation.');
    const result = this.#processLargeDataset();
    console.log('Report generation complete.');
    return result;
  }
}

const generator = new ReportGenerator();
generator.generate();

// Console Output:
// Starting report generation.
// Executing #processLargeDataset...
// Execution of #processLargeDataset finished in 150.75ms. (Time will vary)
// Report generation complete.

            

              
                Copy
              
            
          

फक्त एका ओळीने, `@logExecutionTime` सह, आम्ही आमच्या प्रायव्हेट मेथडमध्ये अत्याधुनिक परफॉर्मन्स मॉनिटरिंग जोडले आहे. हा डेकोरेटर आता एक पुन्हा वापरता येण्याजोगे साधन आहे जे आमच्या संपूर्ण कोडबेसमधील कोणत्याही पब्लिक किंवा प्रायव्हेट मेथडवर लागू केले जाऊ शकते.

उदाहरण: @memoize सह कॅशिंग/मेमोइझेशन

ज्या प्रायव्हेट मेथड्सना गणनेसाठी जास्त वेळ लागतो आणि ज्या शुद्ध आहेत (म्हणजे, समान इनपुटसाठी समान आउटपुट देतात), त्यांच्या परिणामांना कॅश केल्याने परफॉर्मन्समध्ये लक्षणीय सुधारणा होऊ शकते. याला मेमोइझेशन म्हणतात.

            
function memoize(target, context) {
  // Using WeakMap allows the class instance to be garbage collected
  const cache = new WeakMap();

  return function (...args) {
    if (!cache.has(this)) {
      cache.set(this, new Map());
    }
    const instanceCache = cache.get(this);
    const cacheKey = JSON.stringify(args);

    if (instanceCache.has(cacheKey)) {
      console.log(`[Memoize] Returning cached result for ${context.name}`);
      return instanceCache.get(cacheKey);
    }

    const originalMethod = context.access.get(this);
    const result = originalMethod.apply(this, args);
    instanceCache.set(cacheKey, result);

    console.log(`[Memoize] Caching new result for ${context.name}`);
    return result;
  };
}

class FinanceCalculator {
  @memoize
  #calculateComplexTax(income, region) {
    console.log('   -> Performing expensive tax calculation...');
    // Simulate a complex calculation
    for (let i = 0; i < 50000000; i++);
    return (income * 0.2) + (region === 'EU' ? 100 : 50);
  }

  getTaxFor(income, region) {
    return this.#calculateComplexTax(income, region);
  }
}

const calculator = new FinanceCalculator();

console.log('First call:');
calculator.getTaxFor(50000, 'EU');

console.log('\nSecond call (same arguments):');
calculator.getTaxFor(50000, 'EU');

console.log('\nThird call (different arguments):');
calculator.getTaxFor(60000, 'NA');

// Console Output:
// First call:
// [Memoize] Caching new result for #calculateComplexTax
//    -> Performing expensive tax calculation...
// 
// Second call (same arguments):
// [Memoize] Returning cached result for #calculateComplexTax
// 
// Third call (different arguments):
// [Memoize] Caching new result for #calculateComplexTax
//    -> Performing expensive tax calculation...

            

              
                Copy
              
            
          

लक्षात घ्या की महागडी गणना प्रत्येक युनिक युक्तिवादांच्या सेटसाठी फक्त एकदाच चालते. हा पुन्हा वापरता येण्याजोगा `@memoize` डेकोरेटर आता आमच्या ॲप्लिकेशनमधील कोणत्याही शुद्ध प्रायव्हेट मेथडला सुपरचार्ज करू शकतो.

व्यावहारिक उपयोग २: रनटाइम व्हॅलिडेशन आणि असर्शन्स

क्लासची अंतर्गत अखंडता सुनिश्चित करणे अत्यंत महत्त्वाचे आहे. प्रायव्हेट मेथड्स अनेकदा महत्त्वपूर्ण ऑपरेशन्स करतात ज्यात त्यांचे इनपुट वैध स्थितीत आहेत असे गृहीत धरले जाते. डेकोरेटर्स रनटाइमवर या गृहितकांना, किंवा 'कॉन्ट्रॅक्ट्स'ना, लागू करण्याचा एक सुंदर मार्ग प्रदान करतात.

उदाहरण: @validateInput सह इनपुट पॅरामीटर व्हॅलिडेशन

चला एक डेकोरेटर फॅक्टरी तयार करूया—एक फंक्शन जे डेकोरेटर परत करते—प्रायव्हेट मेथडला पास केलेल्या युक्तिवादांची पडताळणी करण्यासाठी. यासाठी, आपण एक साधा स्कीमा वापरू.

            
// Decorator Factory: a function that returns the actual decorator
function validateInput(schemaValidator) {
  return function(target, context) {
    const methodName = context.name;
    return function(...args) {
      if (!schemaValidator(args)) {
        throw new TypeError(`Invalid arguments for private method ${methodName}.`);
      }
      const originalMethod = context.access.get(this);
      return originalMethod.apply(this, args);
    }
  }
}

// A simple schema validator function
const userPayloadSchema = ([user]) => {
  return typeof user === 'object' &&
         user !== null &&
         typeof user.id === 'string' &&
         typeof user.email === 'string' &&
         user.email.includes('@');
};

class UserAPI {
  @validateInput(userPayloadSchema)
  #createSavePayload(user) {
    console.log('Payload is valid, creating DB object.');
    return { db_id: user.id, contact_email: user.email };
  }

  saveUser(user) {
    const payload = this.#createSavePayload(user);
    // ... logic to send payload to the database
    console.log('User saved successfully.');
  }
}

const api = new UserAPI();

// Valid call
api.saveUser({ id: 'user-123', email: 'test@example.com' });

// Invalid call
try {
  api.saveUser({ id: 'user-456', email: 'invalid-email' });
} catch (e) {
  console.error(e.message);
}

// Console Output:
// Payload is valid, creating DB object.
// User saved successfully.
// Invalid arguments for private method #createSavePayload.

            

              
                Copy
              
            
          

हा `@validateInput` डेकोरेटर `#createSavePayload` च्या कॉन्ट्रॅक्टला स्पष्ट आणि स्वयं-अंमलबजावणी करणारा बनवतो. मुख्य मेथड लॉजिक स्वच्छ राहू शकते, या विश्वासाने की त्याचे इनपुट नेहमीच वैध असतात. मोठ्या, आंतरराष्ट्रीय टीममध्ये काम करताना हा पॅटर्न अविश्वसनीयपणे शक्तिशाली आहे, कारण तो अपेक्षांना थेट कोडमध्ये संहिताबद्ध करतो, ज्यामुळे बग्स आणि गैरसमज कमी होतात.

डेकोरेटर्सची साखळी आणि अंमलबजावणीचा क्रम

जेव्हा तुम्ही डेकोरेटर्स एकत्र करता तेव्हा त्यांची शक्ती वाढते. तुम्ही एकाच मेथडवर अनेक डेकोरेटर्स लागू करू शकता, आणि त्यांच्या अंमलबजावणीचा क्रम समजून घेणे आवश्यक आहे.

नियम असा आहे: डेकोरेटर्सचे मूल्यांकन खालून वर (bottom-up) केले जाते, परंतु परिणामी फंक्शन्स वरून खाली (top-down) कार्यान्वित केली जातात.

चला साध्या लॉगिंग डेकोरेटर्ससह हे स्पष्ट करूया:

            
function A(target, context) {
  console.log('Evaluated Decorator A');
  return function(...args) {
    console.log('Executed Wrapper A - Start');
    const original = context.access.get(this);
    const result = original.apply(this, args);
    console.log('Executed Wrapper A - End');
    return result;
  }
}

function B(target, context) {
  console.log('Evaluated Decorator B');
  return function(...args) {
    console.log('Executed Wrapper B - Start');
    const original = context.access.get(this);
    const result = original.apply(this, args);
    console.log('Executed Wrapper B - End');
    return result;
  }
}

class Example {
  @A
  @B
  #doWork() {
    console.log('   -> Core #doWork logic is running...');
  }

  run() {
    this.#doWork();
  }
}

console.log('--- Defining Class ---');
const ex = new Example();
console.log('\n--- Calling Method ---');
ex.run();

// Console Output:
// --- Defining Class ---
// Evaluated Decorator B
// Evaluated Decorator A
// 
// --- Calling Method ---
// Executed Wrapper A - Start
// Executed Wrapper B - Start
//    -> Core #doWork logic is running...
// Executed Wrapper B - End
// Executed Wrapper A - End

            

              
                Copy
              
            
          

जसे तुम्ही पाहू शकता, क्लासच्या व्याख्येदरम्यान, डेकोरेटर B चे मूल्यांकन प्रथम झाले, नंतर A चे. जेव्हा मेथड कॉल केली गेली, तेव्हा A चे रॅपर फंक्शन प्रथम कार्यान्वित झाले, ज्याने नंतर B च्या रॅपरला कॉल केले, आणि ज्याने शेवटी मूळ `#doWork` मेथडला कॉल केले. हे एखाद्या भेटवस्तूला कागदाच्या अनेक थरांमध्ये गुंडाळण्यासारखे आहे; तुम्ही सर्वात आतला थर (B) प्रथम लावता, नंतर पुढचा थर (A), पण जेव्हा तुम्ही ते उघडता, तेव्हा तुम्ही सर्वात बाहेरचा थर (A) प्रथम काढता, नंतर पुढचा (B).

जागतिक दृष्टीकोन: आधुनिक विकासासाठी हे का महत्त्वाचे आहे

जावास्क्रिप्ट प्रायव्हेट मेथड डेकोरेटर्स केवळ सिंटॅक्टिक शुगरपेक्षा अधिक आहेत; ते स्केलेबल, एंटरप्राइझ-ग्रेड ॲप्लिकेशन्स तयार करण्याच्या दिशेने एक महत्त्वपूर्ण पाऊल दर्शवतात. जागतिक विकास समुदायासाठी हे का महत्त्वाचे आहे ते येथे आहे:

• सुधारित देखभालक्षमता: कन्सर्न्स वेगळे करून, डेकोरेटर्स कोडबेस समजण्यास सोपे करतात. टोकियोमधील एक डेव्हलपर बर्लिनमधील सहकाऱ्याने लिहिलेल्या लॉगिंग, कॅशिंग किंवा व्हॅलिडेशनच्या बॉयलरप्लेटमध्ये न हरवता मेथडच्या मूळ लॉजिकला समजू शकतो.
• वर्धित पुनर्वापरयोग्यता: एक चांगला लिहिलेला डेकोरेटर हा कोडचा अत्यंत पुनर्वापर करण्यायोग्य तुकडा आहे. एकच `@validate` किंवा `@logExecutionTime` डेकोरेटर शेकडो घटकांमध्ये इम्पोर्ट आणि वापरला जाऊ शकतो, ज्यामुळे सुसंगतता सुनिश्चित होते आणि कोडची पुनरावृत्ती कमी होते.
• प्रमाणित संकेत: मोठ्या, वितरित संघांमध्ये, डेकोरेटर्स कोडिंग मानके आणि आर्किटेक्चरल पॅटर्न लागू करण्यासाठी एक शक्तिशाली यंत्रणा प्रदान करतात. एक प्रमुख आर्किटेक्ट ऑथेंटिकेशन, फीचर फ्लॅगिंग किंवा आंतरराष्ट्रीयीकरणासारख्या समस्या हाताळण्यासाठी मंजूर डेकोरेटर्सचा एक संच परिभाषित करू शकतो, ज्यामुळे प्रत्येक डेव्हलपर या वैशिष्ट्यांची अंमलबजावणी सुसंगत, अंदाजे मार्गाने करतो हे सुनिश्चित होते.
• फ्रेमवर्क आणि लायब्ररी डिझाइन: फ्रेमवर्क आणि लायब्ररीच्या लेखकांसाठी, डेकोरेटर्स एक स्वच्छ, घोषणात्मक API प्रदान करतात. हे लायब्ररीच्या वापरकर्त्यांना एका साध्या `@` सिंटॅक्ससह जटिल वर्तनांमध्ये निवड करण्याची परवानगी देते, ज्यामुळे अधिक अंतर्ज्ञानी आणि आनंददायक डेव्हलपर अनुभव मिळतो.

निष्कर्ष: क्लास-आधारित प्रोग्रामिंगचे एक नवीन युग

जावास्क्रिप्ट प्रायव्हेट मेथड डेकोरेटर्स क्लासेसच्या अंतर्गत वर्तनात वाढ करण्यासाठी एक सुरक्षित आणि सुंदर मार्ग प्रदान करतात. ते डेव्हलपर्सना एन्कॅप्सुलेशन आणि सिंगल रिस्पॉन्सिबिलिटीच्या मूळ तत्त्वांशी तडजोड न करता AOP, मेमोइझेशन आणि रनटाइम व्हॅलिडेशन सारखे शक्तिशाली पॅटर्न लागू करण्यास सक्षम करतात.

क्रॉस-कटिंग कन्सर्न्सना पुन्हा वापरता येण्याजोग्या, घोषणात्मक डेकोरेटर्समध्ये अमूर्त करून, आपण केवळ अधिक शक्तिशालीच नव्हे तर वाचायला, देखभालीसाठी आणि स्केल करायला लक्षणीयरीत्या सोप्या प्रणाली तयार करू शकतो. जसजसे डेकोरेटर्स जावास्क्रिप्ट भाषेचा एक मूळ भाग बनतील, तसतसे ते निःसंशयपणे जगभरातील व्यावसायिक डेव्हलपर्ससाठी एक अपरिहार्य साधन बनतील, ज्यामुळे ऑब्जेक्ट-ओरिएंटेड आणि कंपोनंट-आधारित डिझाइनमध्ये एक नवीन स्तराची अत्याधुनिकता आणि स्पष्टता येईल.

आज ते वापरण्यासाठी तुम्हाला अजूनही बॅबेल (Babel) सारख्या साधनाची आवश्यकता भासू शकते, परंतु हे परिवर्तनकारी वैशिष्ट्य शिकण्यास आणि प्रयोग करण्यास प्रारंभ करण्याची हीच योग्य वेळ आहे. स्वच्छ, शक्तिशाली आणि सुव्यवस्थित जावास्क्रिप्ट क्लासेसचे भविष्य येथे आहे, आणि ते डेकोरेटेड आहे.